import axios from 'axios';
import { ElMessage } from 'element-plus'; // 若未用Element Plus，可替换为其他提示组件

// 创建Axios实例
const service = axios.create({
  baseURL: import.meta.env.VITE_GO_URL || '', // 使用Vite代理，留空即可
  withCredentials: true,
  timeout: 15000, // 增加超时时间到15秒
  headers: {
    'Content-Type': 'application/json;charset=utf-8'
  }
});

// 存储待取消的请求（防止重复请求）
const pendingRequests = new Map();

// 生成请求唯一标识
const getRequestKey = (config) => {
  const { method, url, params, data } = config;
  return [
    method,
    url,
    params ? JSON.stringify(params) : '',
    data ? JSON.stringify(data) : ''
  ].join('-');
};

// 请求拦截器
service.interceptors.request.use(
  (config) => {
    // 优化重复请求处理：只在相同请求间隔很短时才取消
    const requestKey = getRequestKey(config);
    const now = Date.now();
    
    if (pendingRequests.has(requestKey)) {
      const existingRequest = pendingRequests.get(requestKey);
      
      // 更智能的重复检测：
      // 1. 健康检查类请求不取消（可能需要多次检查）
      // 2. 只有非常短的时间间隔（100ms）才认为是真正的重复点击
      const isHealthCheck = config.url?.includes('/health') || config.url?.includes('/test');
      const isVeryQuickDuplicate = (now - existingRequest.timestamp) < 100;
      
      if (!isHealthCheck && isVeryQuickDuplicate) {
        console.log('🔄 取消重复请求:', config.url, '(间隔:', now - existingRequest.timestamp, 'ms)');
        existingRequest.controller.abort();
      }
      pendingRequests.delete(requestKey);
    }
    
    // 创建新的取消控制器
    const abortController = new AbortController();
    config.signal = abortController.signal;
    pendingRequests.set(requestKey, {
      controller: abortController,
      timestamp: now
    });

    // 添加Token（从localStorage或Cookie获取，避免使用Composition API）
    try {
      const tokenInfo = localStorage.getItem('tokenInfo');
      if (tokenInfo) {
        const parsedToken = JSON.parse(tokenInfo);
        if (parsedToken.token) {
          config.headers.Authorization = `Bearer ${parsedToken.token}`;
        }
      }
    } catch (error) {
      // 静默处理token解析错误
      console.warn('Token解析失败:', error);
    }

    return config;
  },
  (error) => {
    ElMessage({
      message: '请求参数错误',
      type: 'error'
    });
    return Promise.reject(error);
  }
);

// 响应拦截器
service.interceptors.response.use(
  (response) => {
    // 移除已完成的请求
    const requestKey = getRequestKey(response.config);
    if (pendingRequests.has(requestKey)) {
      pendingRequests.delete(requestKey);
      console.log('✅ 请求完成:', response.config.url);
    }

    // 处理业务响应（根据后端实际格式调整）
    const res = response.data;
    // 假设后端成功状态码为200，其他为错误
    if (res.code !== 200) {
      ElMessage({
        message: res.message || '操作失败',
        type: 'error'
      });
      return Promise.reject(res);
    }
    return res; // 直接返回data，简化调用
  },
  (error) => {
    // 移除已完成的请求
    if (error.config) {
      const requestKey = getRequestKey(error.config);
      pendingRequests.delete(requestKey);
    }

    // 处理取消请求的情况
    if (axios.isCancel(error) || error.name === 'CancelledError' || error.code === 'ERR_CANCELED') {
      // 只在开发环境记录取消日志，生产环境静默处理
      if (import.meta.env.DEV) {
        console.log('⚠️ 请求被取消:', error.config?.url);
      }
      // 取消的请求不显示错误消息，静默处理
      return Promise.reject(error);
    }

    // 处理HTTP错误
    let errorMsg = '网络异常，请稍后重试';

    if (error.response) {
      const { status, data } = error.response;
      errorMsg = data?.message || `请求错误 (${status})`;

      // 处理401未授权（Token过期/未登录）
      if (status === 401) {
        errorMsg = '登录状态已失效，请重新登录';
        // 清除登录状态并跳转到后端登录页（Session方式）
        localStorage.removeItem('tokenInfo');
        const BACKEND_URL = import.meta.env.VITE_GO_URL || 'http://localhost:8181';
        window.location.href = `${BACKEND_URL}/`;
      }
    }

    ElMessage({
      message: errorMsg,
      type: 'error'
    });

    return Promise.reject(error);
  }
);

// 封装常用请求方法
const request = (config) => service(config);

const get = (url, params, config = {}) => {
  return service.get(url, { params, ...config });
};

const post = (url, data, config = {}) => {
  return service.post(url, data, config);
};

const put = (url, data, config = {}) => {
  return service.put(url, data, config);
};

const del = (url, config = {}) => {
  return service.delete(url, config);
};

// 取消所有 pending 状态的请求（如页面跳转时）
const cancelAllRequests = () => {
  pendingRequests.forEach((controller) => {
    controller.abort();
  });
  pendingRequests.clear();
};

export { request, get, post, put, del, cancelAllRequests };
export default service;
